/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: mac
 * Date: 2022-08-21
 * Time: 17:28
 */
//定义类
class Person {
    //字段 -》属性 —》成员变量 -》类的内部 方法的外部的
    //成员变量-》静态~普通
    private String name;
    //private 修饰的变量被封装起来了，只能在类里边使用
    //public String name;
    //public int age;
    private int age = 19;
    public static int count = 10;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    {
        this.age = 99;
        System.out.println("实例代码块！");
    }

    static {
        count = 99;
        System.out.println("静态代码块！");
    }
    public Person(){
        this("gaobo", 18);//调用带有一个参数的构造方法
        //只能有一条this语句，因为必须要放到第一行
        System.out.println("Person(): : 不带参数的调用方法");
    }

    public Person(String name){
        this.name = name;
        System.out.println("Person(String):: 带一个String参数的构造方法");
    }

    public Person(String name, int age){
        this.name = name;
        this.age = age;
        System.out.println("Person(String):: 带2个String，int参数的构造方法");
    }


    /*public void setAge(int age){
        this.age = age;//变量名不能相同，若相同 - this
        //this代表当前对象的引用
    }
    public int getAge(){
        return age;
    }
    public void setName(String myName){
        name = myName;
    }

    public String getName(){
        return name;
    }*/

    //静态成员变量 - 方法区 - 通过类来访问 - 不可以在方法内定义的
    //1.存储代码的片段
    //2..java -> .class(字节码文件）-> 方法区(.class1 .class2 count)
    //3.访问方式 - 类名.成员名/不依赖对象

    //方法-》行为
    //普通的方法内部，不能够定义静态的变量
    //1.static定义的变量，类变量，属于类的
    //2.eat方法调用需要对应引用来调用。但是如果可以定义static的变量， Person就可以调用
    public void eat() {//成员方法 -》静态~普通
        //static int count = 0;
        System.out.println(name + "正在吃饭");
    }

    public void sleep() {
        this.eat();
        //staticFunc();
        System.out.println(name + "正在睡觉");
    }

    //静态方法内部不可以调用普通的方法
    //1.普通方法依赖于对象
    //2.静态方法依赖于类
    public static void staticFunc(){
        //sleep();
        System.out.println("static::func()");
    }

    //默认打印引用地址时，调用toString函数
    /*public String toString(){
        return "gaobo";
    }*/

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class ClassDemo {
    /*public static void main1(String[] args) {
        //Person person = null;
        Person person1 = new Person();//实例化对象
        Person person2 = new Person();//实例化对象
        Person person3 = new Person();//实例化对象
        Person person4 = new Person();//实例化对象
        Person person5 = new Person();//实例化对象

    }

    public static void main2(String[] args) {
        Person person = new Person();
        //成员变量的访问需要通过
        person.name = "bit";
        person.age = 10;
        System.out.println(person.name);
        System.out.println(person.age);//默认数据类型在类中有默认初始数据
        System.out.println("+++++++++++++++++");
        Person person1 = new Person();
        person1.name = "bit";
        person1.age = 19;
        System.out.println(person1.name);
        System.out.println(person1.age);
        person.eat();
        person.sleep();
    }
    //person 是一个变量， 不是地址。只不过这个变量 - 存地址，所以也被叫做引用
    public static void main3(String[] args) {
        Person person = new Person();
        person.name = "bit";
        person.age = 99;
        System.out.println(person.name);
        System.out.println(person.age);
        person.eat();
        person.sleep();
        System.out.println("======================");
        Person person1 = new Person();
        person1.name = "gaobo";
        person1.age = 10;
    }

    public static void main4(String[] args) {
        Person person = new Person();
        //成员变量的访问需要通过
        person.age++;
        System.out.println(person.age);

        System.out.println("==================");

        Person person1 = new Person();
        person1.age++;
        System.out.println(person1.age);
    }
    public static void main5(String[] args) {
        Person person = new Person();
        person.count++;
        //成员变量的访问需要通过
        Person.count++;//直接通过类名来访问
        System.out.println(Person.count);

        System.out.println("==================");
        Person person1 = new Person();
        person1.count++;
        Person.count++;
        System.out.println(Person.count);
    }

    public static void main6(String[] args) {
        //Person.staticFunc();
        Person person = new Person();
        person.sleep();
    }

    public static void main7(String[] args) {
        Person person = new Person();
        Person person1 = person;
        //一个引用不可以同时指向多个对象
        person = new Person();
        person = new Person();
        person = new Person();
    }
*/
    public static void main8(String[] args) {
        Person person = new Person();
        //person.name = "bit";
        person.setName("bit");
        person.setAge(13);
        System.out.println(person.getName());
        System.out.println(person.getAge());
    }

    //构造方法：- 构造对象
    //方法名 和 类名是相同的，且构造方法比较特殊，没有返回值。
    //构造方法是干嘛的？
    //1.为对象分配内存
    //2.调用合适的构造方法 - 表示构造方法不止一个
    //3.每个类至少有一个构造方法 - 如果，没有实现任何的构造方法，
    //编译器会帮我们实现一个构造方法
    //4.如果当前类有其他的构造方法，那么，编译器就不会帮我们生成不带参数的构造方法
    //5.构造方法之减可以构成重载
    public static void main9(String[] args) {
        Person person = new Person();
        System.out.println(person);
        System.out.println("+++++++++");
        Person person1 = new Person("bit");
        System.out.println("+++++++++");
        Person person2 = new Person("bit", 19);
    }

    //this && super
    //this:习惯使用
    //1.this.data 调用对象的属性
    //2.this.func() 调用当前对象的方法
    //3.this() 调用当前对象的其它构造方法 - 只能存放在构造函数中

    public static void main10(String[] args) {
        Person person1 = new Person();
        System.out.println("===========");
        Person person2 = new Person();
    }

    //实例代码块 + 静态代码块 在构造方法之前还会打印
    //1.静态代码块 2.实例代码块 3.构造方法
    //静态代码块只被执行了一次 - 且无需实例化即可使用

    public static void main11(String[] args) {
        System.out.println(Person.count);
    }
    //如果都是静态的，则和定义的顺序有关

    //匿名化对象 - 只能用一次
    public static void main12(String[] args) {
        new Person().eat();
        new Person().sleep();
        System.out.println(new Person());
    }

    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person);
    }
}





















































